/** 
 * UIMA Annotation Mapper
 * Copyright (C) 2010  Nicolas Hernandez
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package fr.univnantes.lina.uima.mapper.annotation;
import java.util.*;

import org.apache.uima.UimaContext;
import org.apache.uima.analysis_engine.AnalysisEngineProcessException;
import org.apache.uima.cas.FSIterator;
import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.jcas.JCas;
import org.apache.uima.resource.ResourceInitializationException;
import java.io.File;

import fr.univnantes.lina.java.util.DateUtilities;
import fr.univnantes.lina.uima.common.AnnotationCollectionUtils;
import fr.univnantes.lina.uima.common.CommonAE;
import fr.univnantes.lina.uima.mapper.rules.RuleProcessor;
import fr.univnantes.lina.uima.mapper.rules.RulesFileLoader;
import fr.univnantes.lina.uima.mapper.rules.JAXB.*;

/**
 * Class for processing the mapping
 * <ul>
 * <li> 
 * </ul>
 * 
 * @author      Nicolas Hernandez
 * @author      Emilien Ripoche, Charles Vukelic, Samuel Ngahane, Jerome Mace et Warren Eslan
 * @version     %I%, %G%
 * @since       1.0
 */
public class AnnotationMapperAE  extends CommonAE { 
	//extends JCasAnnotator_ImplBase {

	/**
	 * Properties param and default values 
	 */
	private static String RULE_FILE_PATH_PARAM = "RulesFile";
	
	/**
	 * Rules to proceed
	 */
	private Rules rules = null;
	
	/**
	 * @return the rules
	 */
	protected Rules getRules() {
		return rules;
	}


	/**
	 * @param rules the rules to set
	 */
	protected void setRules(Rules rules) {
		this.rules = rules;
	}



	//On suppose que le fichier Xml est contenu dans le répertoire resources situé dans le path du projet
	public void initialize(UimaContext context) throws ResourceInitializationException
	{
		
		// super
		super.initialize(context);

		// current AE parameter
		
		// Récupération du nom du fichier de règles passé en paramètre
		// (se trouvant probablement dans répertoire resources mais avant tout dans le classpath)
		// rules file path (relatively to the class path) 
		// URL urlRulesFile = null;
		String ruleFilePath = (String) context.getConfigParameterValue(RULE_FILE_PATH_PARAM);
		File rulesFile = new File(ruleFilePath);
		if (!rulesFile.exists()) {
			String errorMsg =    "The rule input file,  " + ruleFilePath + ", is not valid." ;
			System.err.println("Error: "+errorMsg);
			throw new ResourceInitializationException(); //errorMsg,  new Object[]{errorMsg}) ;
			//System.err.println("Error: "+errorMsg);
			//throw new Exception();
			//					errorMsg, 
			//	     new Object[]{errorMsg});
		}
		
		////try {
			//Récupération du paramètre, le nom du fichier de règles se trouvant dans resources
		//	RULE_FILE_PATH_PARAM = (String) context.getConfigParameterValue(RULE_FILE_PATH_PARAM);
		//	String strUrl = "file://"+System.getProperty("user.dir")+"/resources/"+RULE_FILE_PATH_PARAM;
		//	//Création d'une URL à partir de ce nom
		//	urlRulesFile = new URL(strUrl);
		//} catch (MalformedURLException e) {
		//	e.printStackTrace();
		//}

		// Chargement des règles
		this.setRules(RulesFileLoader.loadRulesFromJAXBFile(rulesFile));
	}


	/**
	 * Process input view
	 */
	//	@Override
	protected String processInputView(JCas aInputViewJCas,
			FSIterator contextAnnotationsFSIter,
			HashMap<String, Integer> inputAnnotationStringHashMap,
			String inputFeatureString, JCas outputViewJCas,
			String outputAnnotationString, String ouputFeatureString)
	throws AnalysisEngineProcessException {
		
		//System.out.println("Debug: class>"+this.getClass().getName()+"< now>" + JavaUtilities.now());

		// Récupération des règles à traiter
		Iterator<Rule> itRules = this.getRules().getRule().iterator();
		
		// Récupération d'un index d'annotations 
		HashMap<String, Integer> annotationHashMap = new HashMap<String, Integer>();
		ArrayList<FeatureStructure> annotationArrayList = AnnotationCollectionUtils.getAnnotationArray(aInputViewJCas, annotationHashMap);
		// Eventuellement sort de cet index
		
		// Pour chaque annotation on consulte les règles à traiter
		
		// Parcours de chaque règle et exécution
		// Attention cet algo n'est applicable que dans le cas où il n'y a q'un seul patternElement 
		// Sinon celui-ci est à revoir
		while(itRules.hasNext()) {
			Rule aRule = itRules.next();
			//System.out.println("Debug: aRule.getId() "+ aRule.getId());
			RuleProcessor.processRule(aRule,aInputViewJCas);
			
		}
		
		// La méthode processInputView requiert de retourner quelque chose 
		// Le plus simple est de lui retourner l'image d'elle même
		return aInputViewJCas.getSofaDataString();
	}
}
